/**
 * 产品列表页面逻辑
 *
 * @author AI Crawlers Team
 * @date 2025-10-10
 */

// 清理可能存在的旧实例
if (typeof productList !== 'undefined' && productList.table) {
    try {
        productList.table.destroy();
        $('#productTable').empty();
    } catch (e) {
        console.log('清理旧产品列表实例:', e);
    }
}

var productList = {
    
    // DataTable实例
    table: null,
    
    // 当前正在配置竞品的产品ID
    currentProductId: null,
    
    /**
     * 初始化
     */
    init() {
        this.loadCategories();
        this.initTable();
        this.bindEvents();
    },
    
    /**
     * 加载产品类别列表
     */
    async loadCategories() {
        try {
            const res = await axios.get(`${API_CONFIG.BASE_URL}/categories`);
            
            // axios拦截器返回的是 response.data，即 { code: 200, message: "success", data: [...] }
            const categories = res.data || [];
            
            console.log('✅ 类别API响应:', res);
            console.log('✅ 类别列表:', categories);
            
            // 填充搜索框的类别下拉
            const searchSelect = $('#searchCategory');
            searchSelect.empty();
            searchSelect.append('<option value="">全部类别</option>');
            categories.forEach(cat => {
                searchSelect.append(`<option value="${cat.categoryName}">${cat.categoryName}</option>`);
            });
            
            // 填充表单的类别下拉
            const formSelect = $('#productCategory');
            formSelect.empty();
            formSelect.append('<option value="">请选择</option>');
            categories.forEach(cat => {
                formSelect.append(`<option value="${cat.categoryName}">${cat.categoryName}</option>`);
            });
            
            console.log(`✅ 成功加载 ${categories.length} 个产品类别`);
        } catch (error) {
            console.error('❌ 加载产品类别失败：', error);
            // 失败时使用默认值
            const defaultCategories = ['保险柜', '家用保险柜', '商用保险柜'];
            const searchSelect = $('#searchCategory');
            const formSelect = $('#productCategory');
            
            searchSelect.empty();
            searchSelect.append('<option value="">全部类别</option>');
            formSelect.empty();
            formSelect.append('<option value="">请选择</option>');
            
            defaultCategories.forEach(cat => {
                searchSelect.append(`<option value="${cat}">${cat}</option>`);
                formSelect.append(`<option value="${cat}">${cat}</option>`);
            });
        }
    },
    
    /**
     * 初始化表格
     */
    initTable() {
        this.table = $('#productTable').DataTable({
            processing: true,
            serverSide: true,
            ajax: {
                url: API_CONFIG.BASE_URL + '/products',
                type: 'GET',
                data: function(d) {
                    return {
                        page: Math.floor(d.start / d.length) + 1,
                        size: d.length,
                        keyword: $('#searchKeyword').val(),
                        category: $('#searchCategory').val(),
                        isOurProduct: $('#searchIsOurProduct').val(),
                        status: $('#searchStatus').val()
                    };
                },
                dataSrc: function(json) {
                    console.log('DataTable收到的数据:', json);
                    if (!json || !json.data) {
                        console.error('数据格式错误:', json);
                        return [];
                    }
                    json.recordsTotal = json.data.total || 0;
                    json.recordsFiltered = json.data.total || 0;
                    return json.data.list || [];
                },
                error: function(xhr, error, thrown) {
                    console.error('DataTable加载错误:', error, thrown);
                    console.error('响应:', xhr.responseText);
                    utils.error('加载产品列表失败，请检查网络或后端服务');
                }
            },
            columns: [
                { 
                    data: 'productId',
                    className: 'text-center'
                },
                { 
                    data: 'productName',
                    render: function(data, type, row) {
                        return `<strong>${utils.escapeHtml(data)}</strong>`;
                    }
                },
                { 
                    data: 'brand',
                    className: 'text-center',
                    render: function(data) {
                        return data || '-';
                    }
                },
                { 
                    data: 'model',
                    className: 'text-center',
                    render: function(data) {
                        return data || '-';
                    }
                },
                { 
                    data: 'category',
                    className: 'text-center',
                    render: function(data) {
                        return data ? `<span class="badge bg-info">${data}</span>` : '-';
                    }
                },
                { 
                    data: 'priceRange',
                    className: 'text-center',
                    render: function(data) {
                        return data || '-';
                    }
                },
                { 
                    data: 'isOurProduct',
                    className: 'text-center',
                    render: function(data) {
                        if (data === 1) {
                            return '<span class="badge bg-success">我方产品</span>';
                        } else {
                            return '<span class="badge bg-warning">竞品</span>';
                        }
                    }
                },
                { 
                    data: 'focusLevel',
                    className: 'text-center',
                    render: function(data) {
                        const levelMap = {
                            'high': '<span class="badge bg-danger">重点</span>',
                            'normal': '<span class="badge bg-info">一般</span>',
                            'low': '<span class="badge bg-secondary">低</span>'
                        };
                        return levelMap[data] || '-';
                    }
                },
                { 
                    data: 'status',
                    className: 'text-center',
                    render: function(data) {
                        const statusClass = utils.getStatusClass(data);
                        const statusText = utils.getStatusText(data);
                        return `<span class="badge bg-${statusClass}">${statusText}</span>`;
                    }
                },
                { 
                    data: 'createTime',
                    className: 'text-center',
                    render: function(data) {
                        return utils.formatDate(data);
                    }
                },
                {
                    data: null,
                    orderable: false,
                    className: 'text-center',
                    render: function(data, type, row) {
                        let buttons = `
                            <button class="btn btn-sm btn-primary" onclick="productList.edit(${row.productId})">
                                编辑
                            </button>
                            <button class="btn btn-sm btn-danger" onclick="productList.delete(${row.productId})">
                                删除
                            </button>
                        `;
                        
                        // 如果是我方产品，显示"配置竞品"按钮
                        if (row.isOurProduct === 1) {
                            buttons += `
                                <button class="btn btn-sm btn-info" onclick="productList.configCompetitors(${row.productId})">
                                    配置竞品
                                </button>
                            `;
                        }
                        
                        return buttons;
                    }
                }
            ],
            language: {
                url: '//cdn.datatables.net/plug-ins/1.13.7/i18n/zh.json'
            },
            pageLength: API_CONFIG.PAGE_SIZE,
            lengthMenu: API_CONFIG.PAGE_SIZE_OPTIONS.map(size => [size, `${size} 条/页`]),
            order: [[0, 'desc']]
        });
    },
    
    /**
     * 绑定事件
     */
    bindEvents() {
        // 搜索框回车
        $('#searchKeyword').on('keypress', function(e) {
            if (e.which === 13) {
                productList.search();
            }
        });
        
        // 产品类型变化时，显示/隐藏竞品字段
        $('#isOurProduct').on('change', function() {
            if ($(this).val() === '0') {
                $('#competitorFields').show();
            } else {
                $('#competitorFields').hide();
            }
        });
    },
    
    /**
     * 搜索
     */
    search() {
        this.table.ajax.reload();
    },
    
    /**
     * 重置搜索
     */
    reset() {
        $('#searchKeyword').val('');
        $('#searchCategory').val('');
        $('#searchIsOurProduct').val('');
        $('#searchStatus').val('');
        this.table.ajax.reload();
    },
    
    /**
     * 显示添加对话框
     */
    showAddDialog() {
        $('#productFormModal .modal-title').text('添加产品');
        $('#productForm')[0].reset();
        $('#productId').val('');
        $('#isOurProduct').val('1');
        $('#focusLevel').val('normal');
        $('#productStatus').val('on_sale');
        $('#status').val('1');
        $('#competitorFields').hide();
        
        new bootstrap.Modal('#productFormModal').show();
    },
    
    /**
     * 编辑
     */
    async edit(id) {
        try {
            utils.showLoading('加载中...');
            const res = await productApi.getById(id);
            utils.hideLoading();
            
            const product = res.data;
            
            // 填充表单
            $('#productFormModal .modal-title').text('编辑产品');
            $('#productId').val(product.productId);
            $('#productName').val(product.productName);
            $('#productBrand').val(product.brand || '');
            $('#productModel').val(product.model || '');
            $('#productCategory').val(product.category || '');
            $('#priceRange').val(product.priceRange || '');
            $('#isOurProduct').val(product.isOurProduct);
            $('#competitorLevel').val(product.competitorLevel || '');
            $('#focusLevel').val(product.focusLevel || 'normal');
            $('#keywords').val(product.keywords ? product.keywords.join(',') : '');
            $('#aliases').val(product.aliases ? product.aliases.join(',') : '');
            $('#productDescription').val(product.description || '');
            $('#productStatus').val(product.productStatus || 'on_sale');
            $('#status').val(product.status);
            $('#productRemark').val(product.remark || '');
            
            // 显示/隐藏竞品字段
            if (product.isOurProduct === 0) {
                $('#competitorFields').show();
            } else {
                $('#competitorFields').hide();
            }
            
            new bootstrap.Modal('#productFormModal').show();
        } catch (error) {
            utils.hideLoading();
            console.error('加载产品失败：', error);
        }
    },
    
    /**
     * 保存
     */
    async save() {
        const id = $('#productId').val();
        
        // 获取表单数据
        const data = {
            productName: $('#productName').val().trim(),
            brand: $('#productBrand').val().trim(),
            model: $('#productModel').val().trim(),
            category: $('#productCategory').val(),
            priceRange: $('#priceRange').val().trim(),
            isOurProduct: parseInt($('#isOurProduct').val()),
            competitorLevel: $('#competitorLevel').val(),
            focusLevel: $('#focusLevel').val(),
            keywords: utils.stringToArray($('#keywords').val()),
            aliases: utils.stringToArray($('#aliases').val()),
            description: $('#productDescription').val().trim(),
            productStatus: $('#productStatus').val(),
            status: parseInt($('#status').val()),
            remark: $('#productRemark').val().trim()
        };
        
        // 表单验证
        if (!data.productName) {
            utils.error('请输入产品名称');
            return;
        }
        
        try {
            utils.showLoading('保存中...');
            
            if (id) {
                // 更新
                await productApi.update(id, data);
            } else {
                // 创建
                await productApi.create(data);
            }
            
            utils.hideLoading();
            utils.success('保存成功');
            
            // 关闭对话框
            bootstrap.Modal.getInstance('#productFormModal').hide();
            
            // 刷新表格
            this.table.ajax.reload();
            
        } catch (error) {
            utils.hideLoading();
            console.error('保存产品失败：', error);
        }
    },
    
    /**
     * 删除
     */
    async delete(id) {
        const confirmed = await utils.confirm('确定要删除这个产品吗？删除后无法恢复。', '删除确认');
        if (!confirmed) return;
        
        try {
            utils.showLoading('删除中...');
            await productApi.delete(id);
            utils.hideLoading();
            
            utils.success('删除成功');
            this.table.ajax.reload();
            
        } catch (error) {
            utils.hideLoading();
            console.error('删除产品失败：', error);
        }
    },
    
    /**
     * 配置竞品
     */
    async configCompetitors(id) {
        this.currentProductId = id;
        
        try {
            utils.showLoading('加载中...');
            
            // 获取产品信息
            const productRes = await productApi.getById(id);
            const product = productRes.data;
            
            // 获取竞品列表
            const competitorsRes = await axios.get(`${API_CONFIG.BASE_URL}/products/${id}/competitors`);
            
            // axios拦截器返回的是 response.data，即 { code: 200, message: "success", data: [...] }
            const competitors = competitorsRes.data || [];
            
            console.log('✅ 竞品API响应:', competitorsRes);
            console.log('✅ 竞品列表:', competitors);
            
            utils.hideLoading();
            
            // 显示产品名称
            $('#ourProductName').text(product.productName);
            
            // 渲染竞品列表
            this.renderCompetitorList(competitors);
            
            // 显示对话框
            new bootstrap.Modal('#competitorConfigModal').show();
            
        } catch (error) {
            utils.hideLoading();
            console.error('❌ 加载竞品失败：', error);
        }
    },
    
    /**
     * 渲染竞品列表
     */
    renderCompetitorList(competitors) {
        const tbody = $('#competitorListBody');
        tbody.empty();
        
        if (competitors.length === 0) {
            tbody.html('<tr><td colspan="7" class="text-center text-muted">暂无竞品配置</td></tr>');
            return;
        }
        
        competitors.forEach(comp => {
            const typeMap = {
                'direct': '<span class="badge bg-danger">直接竞品</span>',
                'indirect': '<span class="badge bg-warning">间接竞品</span>',
                'potential': '<span class="badge bg-info">潜在竞品</span>'
            };
            
            const strengthMap = {
                'high': '<span class="badge bg-danger">强</span>',
                'medium': '<span class="badge bg-warning">中</span>',
                'low': '<span class="badge bg-info">弱</span>'
            };
            
            const dimensionMap = {
                'all': '全方位',
                'price': '价格',
                'performance': '性能',
                'brand': '品牌',
                'feature': '功能'
            };
            
            const tr = $('<tr></tr>');
            tr.html(`
                <td>${utils.escapeHtml(comp.productName)}</td>
                <td>${utils.escapeHtml(comp.brand || '-')}</td>
                <td>${utils.escapeHtml(comp.priceRange || '-')}</td>
                <td>${typeMap[comp.competitorType] || '-'}</td>
                <td>${strengthMap[comp.strength] || '-'}</td>
                <td>${dimensionMap[comp.dimension] || comp.dimension || '-'}</td>
                <td>
                    <button class="btn btn-sm btn-danger" onclick="productList.removeCompetitor(${comp.productId})">
                        移除
                    </button>
                </td>
            `);
            tbody.append(tr);
        });
        
        console.log(`渲染了 ${competitors.length} 个竞品配置`);
    },
    
    /**
     * 显示添加竞品对话框
     */
    async showAddCompetitorDialog() {
        try {
            // 加载所有竞品（is_our_product=0）
            const res = await productApi.getList({
                page: 1,
                size: 100,
                isOurProduct: 0,
                status: 1
            });
            
            const competitors = res.data.list || [];
            
            // 填充竞品下拉框
            const select = $('#competitorProductId');
            select.empty();
            select.append('<option value="">请选择竞品</option>');
            
            competitors.forEach(comp => {
                select.append(`<option value="${comp.productId}">${comp.productName} (${comp.brand || ''})</option>`);
            });
            
            // 重置表单
            $('#addCompetitorForm')[0].reset();
            $('#competitorType').val('direct');
            $('#competitorStrength').val('medium');
            $('#competitorDimension').val('all');
            
            // 显示对话框
            new bootstrap.Modal('#addCompetitorModal').show();
            
        } catch (error) {
            console.error('加载竞品列表失败：', error);
            utils.error('加载竞品列表失败');
        }
    },
    
    /**
     * 保存竞品关联
     */
    async saveCompetitor() {
        const competitorId = $('#competitorProductId').val();
        
        if (!competitorId) {
            utils.error('请选择竞品');
            return;
        }
        
        const data = {
            competitorProductId: parseInt(competitorId),
            competitorType: $('#competitorType').val(),
            strength: $('#competitorStrength').val(),
            dimension: $('#competitorDimension').val(),
            sortOrder: 0,
            remark: $('#competitorRemark').val().trim()
        };
        
        try {
            utils.showLoading('保存中...');
            
            await axios.post(`${API_CONFIG.BASE_URL}/products/${this.currentProductId}/competitors`, data);
            
            utils.hideLoading();
            utils.success('添加竞品关联成功');
            
            // 获取modal实例
            const addModal = bootstrap.Modal.getInstance('#addCompetitorModal');
            
            // 监听modal完全关闭后再刷新竞品列表
            $('#addCompetitorModal').one('hidden.bs.modal', () => {
                // modal完全关闭后，刷新竞品列表（不重新打开对话框，直接更新列表）
                this.refreshCompetitorList(this.currentProductId);
            });
            
            // 关闭添加对话框
            addModal.hide();
            
        } catch (error) {
            utils.hideLoading();
            console.error('添加竞品关联失败：', error);
        }
    },
    
    /**
     * 刷新竞品列表（不重新打开对话框）
     */
    async refreshCompetitorList(productId) {
        try {
            // 获取竞品列表
            const competitorsRes = await axios.get(`${API_CONFIG.BASE_URL}/products/${productId}/competitors`);
            const competitors = competitorsRes.data || [];
            
            console.log('✅ 刷新竞品列表:', competitors);
            
            // 重新渲染竞品列表
            this.renderCompetitorList(competitors);
            
        } catch (error) {
            console.error('❌ 刷新竞品列表失败：', error);
        }
    },
    
    /**
     * 移除竞品关联
     */
    async removeCompetitor(competitorId) {
        const confirmed = await utils.confirm('确定要移除这个竞品关联吗？', '移除确认');
        if (!confirmed) return;
        
        try {
            utils.showLoading('移除中...');
            
            await axios.delete(`${API_CONFIG.BASE_URL}/products/${this.currentProductId}/competitors/${competitorId}`);
            
            utils.hideLoading();
            utils.success('移除成功');
            
            // 直接刷新竞品列表，不重新打开对话框
            this.refreshCompetitorList(this.currentProductId);
            
        } catch (error) {
            utils.hideLoading();
            console.error('移除竞品关联失败：', error);
        }
    },
    
    /**
     * 显示导入对话框
     */
    showImportDialog() {
        Swal.fire({
            title: '批量导入产品',
            html: `
                <div class="text-start">
                    <input type="file" id="importFile" class="form-control" accept=".xlsx,.xls,.csv">
                    <div class="mt-3">
                        <small class="text-muted">
                            <p>支持Excel（.xlsx, .xls）和CSV格式</p>
                            <p>Excel模板列：产品名称、品牌、型号、产品类别、价格区间、是否我方产品、关键词、产品描述</p>
                            <p class="mb-0"><a href="#" onclick="productList.downloadTemplate()">📥 下载导入模板</a></p>
                        </small>
                    </div>
                </div>
            `,
            width: 600,
            showCancelButton: true,
            confirmButtonText: '开始导入',
            cancelButtonText: '取消',
            preConfirm: () => {
                const fileInput = document.getElementById('importFile');
                const file = fileInput.files[0];
                
                if (!file) {
                    Swal.showValidationMessage('请选择文件');
                    return false;
                }
                
                return file;
            }
        }).then(async (result) => {
            if (result.isConfirmed) {
                try {
                    utils.showLoading('导入中，请稍候...');
                    
                    const res = await productApi.batchImport(result.value);
                    
                    utils.hideLoading();
                    utils.success(`成功导入 ${res.data} 条数据`);
                    
                    // 刷新表格
                    this.table.ajax.reload();
                    
                } catch (error) {
                    utils.hideLoading();
                    console.error('导入失败：', error);
                }
            }
        });
    },
    
    /**
     * 下载导入模板
     */
    downloadTemplate() {
        utils.info('模板下载功能待实现');
    }
};

// 页面加载完成后初始化
$(document).ready(function() {
    // 如果DataTable已存在，先销毁
    if (productList.table) {
        try {
            productList.table.destroy();
        } catch (e) {
            console.log('销毁旧DataTable:', e);
        }
    }
    productList.init();
});

